#include<stdio.h>
#include<string.h>
#define Size 100

typedef struct 
{
    char str[Size];
    size_t len;/* data */
}MyStr;



void GetStr(MyStr *s)
{
    char c=0;
    //读到回车结束
    while ((c=getchar())!='\n'&&s->len<Size-1)
    {
        s->str[s->len++]=c;
    }
    s->str[s->len] = '\0';
}

void FastRost(ElementType *static,ElementType *end)
{
    If( start>=end)
    reutn ;
    int left = start;
    int right = end ;
    int temp = a[start];
    while(left < right)
    {
        while(a[right] > trmp && left < right)
            right--;
            if(left < right)
            a[left++] = a[right];
        while(a[right] > trmp && left < right)
            left++;
            if(left < right)
            a[right] = a[left];
    } 
   a[letf] = temp;
   FastRost(ElementType *static,ElementType *end);
   FastRost(ElementType *static,ElementType *end);
}

[[]]
int main()
{
    MyStr myString;
    myString.len=0;


    GetStr(&myString);
    printf("你输入的字符串是: %s\n", myString.str);

}

void FastRost(数组，开始下标，结束下标)
{
    if（开始下标 大于等于 结束下标）
    return 跳出；
    int letf = 开始下标作为 左下标
    int right =  结束下标作为右下标
    int temp  =  最开始的左值
    while（左下标小于右下标）
    {
        while(右值，大于 temp ，且 左下标 小于 右下标)
            右下标减减；
            if（左下标 小于 右下标）
                左值 ++ =   右值；
         while（右值 小于 temp 且 左下标  大于  右下标）
            左下标++；
            if（左下标  小于  右下标）
                右值 --  =  +
    }
    右值 = temp；
    FastSort(数组,开始下标,左下标-1);
    FastSort(数组,  右下标+1,结束下标);
} 


//链表的快速排序，单向链表  快慢指针
void FastSort(开始指针 类的类型，结束指针，类的类型)
{
    终止   开始等于结束 return
    类的类型 基准值 = 开始指针；
    类的类型 慢速指针 = 开始指针；
    类的    快速指针 =  开始指针下的指向下一个的节点的指针
    while（快速指针  不等于  结束指针）
    {
        if（快速指针类的值  小于  基准值的大小）
        {
            慢速 = 慢速类下的值
            基准值归为std::swap(temp -> value,slow -> value);
        }
        fast = fast - 》next
    }
    std::swap(temp -> value,slow -> value);  //基准值归位
    FastSort(start,slow);       //[start,slow)
    FastSort(slow->next,end);
}




回调
主函数有一个函数，该函数作为参数传入一个回调函数之中
编写类时，考虑到类中元素存在变化可能
编写一个回调函数
将外部的输出函数调入该函数中实现，外部调用目的
那怎么编写类中回调函数你只需要将元素直接返回给函数，让调用的人处理



链表的排序
因为链表具有单向性，增加和删除，修改
对排序和查找的效率比较低

冒泡排序

循环从链表0到最后size-1
每次循环开始，都从head开始
循环从链表0开始到 size-1-i  结束



